package main.java.BLT;
import java.io.BufferedReader;
import java.io.IOException;

import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;



public class BattleLiderTactics {
	
	private Mazo mazoLideres; 
	private Mazo caidosEnCombate;
	private Mazo mazotecnologia;
	private boolean finDePartida;
	private Jugador j1;
	private Jugador j2;
	private TableroResultado tablero;
	
	public BattleLiderTactics() throws IOException{
		finDePartida = false;
		caidosEnCombate = new Mazo();
		mazoLideres=new Mazo("src/main/resources/lider.txt","Lider"); 
		tablero = new TableroResultado();
		mazotecnologia = new Mazo("src/main/resources/especial.txt","Especial");
	}

	public void jugar(){
		
		mazoLideres.mezcla();
		mazotecnologia.mezcla();

		try {
			System.out.print("Seleccione el nombre del primer jugador: ");
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String linea = br.readLine();
			j1 = new Jugador(linea);
		} catch (Exception e) {
			
		}
		try {
			System.out.print("Seleccione el nombre del segundo jugador: ");
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String linea = br.readLine();
			j2 = new Jugador(linea);
		} catch (Exception e) {
		}
	
	//cada jugador coge su carta de lider

		j1.setLider((Lider)mazoLideres.sacaCartaPrimera());
		j2.setLider((Lider)mazoLideres.sacaCartaPrimera());
	
		while(!finDePartida){
			if(!(j1.getBatallasGanadas().equals(0) && j2.getBatallasGanadas().equals(0))){
				System.out.println("\nEl jugador "+j1.getNombre()+" lleva "+j1.getBatallasGanadas()+ " batallas ganadas");
				System.out.println("El jugador "+j2.getNombre()+" lleva "+j2.getBatallasGanadas()+ " batallas ganadas");
			}
			//////////// 1 - ORDENES////////////
			orden(j1, j2);
			///////////// 2 - REAGRUPACION///////////////
			reagrupacion();
			//////////// 3 - INICIATIVA//////////////			
			Integer rLiderMasAlto=comparaLideres(j1,j2);
			if(rLiderMasAlto>0){
				asignaRol(j1, j2);
			}else{
				asignaRol(j2,j1);
			}
			

			if(j1.getRol().toString().equals("Atacante")){
				iteracionTacticas(j1,j2);
			}else{
				iteracionTacticas(j2,j1);
			}
			///// 14 - Fin De La Batalla//////
			//se devuelven las cartas a cada mazo
			restauraCartasJugadas(j1,j2);		
			j1.setBooleanSeleccionaBonusPrimeroLider(false);
			j2.setBooleanSeleccionaBonusPrimeroLider(false);
			//se comprueba si alguien ha ganado las 6 partidas
			decideFinDePartida(j1,j2);
		}
	}
	
	
	//Iteracion del juego en relacion al jugador que será atacante y el que será defensor

	public Jugador iteracionTacticas(Jugador jAtacante, Jugador jDefensor){
		///////////// 4 - TACTICAS ////////////
		decideTactica(jAtacante, jDefensor);
		///////////// 5 - ATAQUE ///////////
		decisionMazoEjercito(jAtacante, jAtacante.getLider().getValorMaximoAtaque());
		////////////// 6 - RETIRADA DEL DEFENSOR ///////////
		retirada(jDefensor);
		///////////// 7 - La Defensa //////////////////////
		decisionMazoEjercito(jDefensor, jDefensor.getLider().getValorMaximoDefensa());
		/////////// 8 - Retirada del atacante ////////////
		retirada(jAtacante);
		//////// 9 - ORDENES COMUNICADAS  ////////////////
		ordenesComunicadas(jAtacante,jDefensor);
		/////// 10 - ORDENES FALLIDAS ///////////////
		return iteracionOrdenesFallidas(jAtacante, jDefensor);
	}
		

	private Jugador iteracionOrdenesFallidas(Jugador jAtacante,Jugador jDefensor) {
		compruebaValorRequiereTactica(jAtacante, jDefensor);
		return iteracionCombate(jAtacante,jDefensor);
	}
	
	public Jugador iteracionCombate(Jugador jAtacante,Jugador jDefensor){
		//////// 11 - EL COMBATE  y  12 - LIDERAZGO SUPERIOR ////////////////
		Jugador jRes= combate(jAtacante,jDefensor);
		if(jRes==null){
			/////// 13 - LA VICTORIA /////////////
			compruebaBonusSegundoLider(jAtacante, jDefensor);	
			return decideGanador(jAtacante, jDefensor);
			
			
		}else if(jRes.equals(jAtacante)){
			return jAtacante;
		}else{
			return jDefensor;
		}

	}


		
/////////*******************************************************************************///////////////////				
/////////******************** Metodos utilizados durante la partida ********************///////////////////
/////////*******************************************************************************//////////////////					
	
		
	// Retirada: 
	//el jugador decide retirarse, para ello cambia su carta tactica por la carta de retirada 
	//y elige una carta de ejercito que enviara al mazo de bajas 
	
	private void retirada(Jugador jugador) {
		if(!jugador.getTactica().getValor().equals(4)){
			System.out.println("\nTurno del jugador: " + jugador.getNombre());
			System.out.println("Su táctica es: " + jugador.getTactica());
			System.out.println("¿Desea cambiar su carta Tactica actual por la carta Tactica 4?");
			Boolean bTactica4=cambiarCartaTactica();
			if(bTactica4){
				jugador.setTactica((Tactica)jugador.getOrdenesDeBatalla().getCartas().get(3));
				System.out.println("Seleccione la carta de Ejercito que desea retirar de su mazo");
	
				Ejercito cartaEjercitoARetirar= (Ejercito)Jugador.seleccionaCarta(jugador.getReservaEnJuego().getCartas());
				jugador.getReserva().getCartas().add(cartaEjercitoARetirar);
				jugador.getReservaEnJuego().getCartas().remove(cartaEjercitoARetirar);
			}
		}
	}
		
	// los jugadores deciden la carta de tactica que van a utilizar
	private void decideTactica(Jugador jAtacante, Jugador jDefensor) {

		Iterator<Jugador> ita = iteracionJugador(jAtacante, jDefensor);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			System.out.println("\nTurno del jugador: " + jugador.getNombre());
			System.out.println("Su Lider es: " + jugador.getLider());
			System.out.println("Elija una carta tactica");
			Tactica tactica= (Tactica)Jugador.seleccionaCarta(jugador.getOrdenesDeBatalla().getCartas());
			jugador.setTactica(tactica);
		}

	}
	
	// el jugador con el lider mas alto decide el rol de cada jugador
	private void asignaRol(Jugador jLiderMasAlto, Jugador jLiderMasBajo){
		System.out.println("\nTurno del jugador: " + jLiderMasAlto.getNombre());
		System.out.println("¿Qué Rol desea tener?");
		Collection<Rol> cRol = new ArrayList<Rol>();
		Atacante a= new Atacante();
		Defensor d= new Defensor();
		cRol.add(a);
		cRol.add(d);
		Boolean bRol=seleccionaRol(cRol);
		if(bRol){
			jLiderMasAlto.setRol(a);
			jLiderMasBajo.setRol(d);
			System.out.println("El jugador " + jLiderMasAlto.getNombre()+ " es atacante y el jugador " + jLiderMasBajo.getNombre() + " es defensor");
		}else{
			jLiderMasAlto.setRol(d);
			jLiderMasBajo.setRol(a);
			System.out.println("El jugador " + jLiderMasBajo.getNombre()+ " es atacante y el jugador " + jLiderMasAlto.getNombre() + " es defensor");
			
		}
	}
	
// Reagrupacion:
// el jugador decide si quiere usar el bonus de su lider que le 
//permite coger un determinado numero de cartas del mazo de bajas

	private void reagrupacion() {
		
		Iterator<Jugador> ita = iteracionJugador(j1, j2);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			if(!jugador.getLider().getBonusPrimero().equals(0)){
				System.out.println("\nTurno del jugador: " + jugador.getNombre());
				System.out.println("¿Desea usar el bonus de su lider?");
				Boolean seleccionBonusLider1= usarBonusLider();
				if(seleccionBonusLider1){
					//utiliza el bonus del lider
					Batalla.usarBonusPrimeroLider(jugador);
					// hay que desactivar el bonus 2
					jugador.setBooleanSeleccionaBonusPrimeroLider(true);
				}
			}
		}
	}
	
//Orden:
// el jugador decide si quiere cambiar su lider 
	
	private void orden(Jugador jug1, Jugador jug2) {
		
		Iterator<Jugador> ita = iteracionJugador(jug1, jug2);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			System.out.println("\nTurno del jugador: " + jugador.getNombre());
			System.out.println("Su Lider es: " + jugador.getLider().toString());
			System.out.println("¿Desea cambiar su lider?");
			Boolean seleccionLider1=cambiaLider();
			if(seleccionLider1){
				//cambia el lider actual 
				Lider lActual1=jugador.getLider();
				caidosEnCombate.getCartas().add(lActual1);
				jugador.setLider((Lider)mazoLideres.sacaCartaPrimera());
				System.out.println("Su nuevo Lider es: " + jugador.getLider().toString());
				
				//eliminar 1 carta de ejercito para retirar
				System.out.println("El jugador "+ jugador.getNombre() +" Debe eliminar una carta de su mazo reserva ");
				Ejercito cartaAEliminar= (Ejercito)Jugador.seleccionaCarta(jugador.getReserva().getCartas());
				jugador.getBajas().getCartas().add(cartaAEliminar);
				jugador.getReserva().getCartas().remove(cartaAEliminar);
			}
		}	
	}
		
// Ordenes Comunicadas:
// se muestran las tacticas y las cartas de ejercito de cada jugador	
	
	public void ordenesComunicadas(Jugador jAtacante, Jugador jDefensor){	
		System.out.println("Carta Tactica del jugador " + jAtacante.getNombre() +": "+ jAtacante.getTactica());
		System.out.println("Carta Tactica del jugador " + jDefensor.getNombre() +": "+ jDefensor.getTactica());
		System.out.println("Mazo de ejercito en juego del jugador " + jAtacante.getNombre() +": "+ jAtacante.getReservaEnJuego().getCartas());
		System.out.println("Mazo de ejercito en juego del jugador " + jDefensor.getNombre() +": "+ jDefensor.getReservaEnJuego().getCartas());
	}

	
//Ordenes fallidas;
//
	
	public Integer ordenesFallidas(Jugador j){
		
		String requiere=j.getTactica().getRequiere();
		ArrayList<Carta> reservaEnJuego= j.getReservaEnJuego().getCartas();
			Integer cont=0;
		for(int i=0;i<reservaEnJuego.size();i++){
			if(reservaEnJuego.get(i).getNombre().equals(requiere)){
				cont++;
			}
		}				
		return cont;						
	}
	
	

	///Combate:
	///se comprueba el resultado del combate

	public Jugador combate(Jugador jAtacante, Jugador jDefensor){
		
		Resultado r;
		if(jAtacante.getTactica().getValor()>=jDefensor.getTactica().getValor()){
			 r= tablero.obtenerResultado(jAtacante.getTactica().getValor(),jDefensor.getTactica().getValor());
		}else{
			 r= tablero.obtenerResultado(jDefensor.getTactica().getValor(),jAtacante.getTactica().getValor());
		}
		
		Integer rJugadorAtacante = r.getResultadoAtacante();
		Integer rJugadorDefensor = r.getResultadoDefensor();
	
		Integer rLiderMasAlto=comparaLideres(jAtacante,jDefensor);
		if(rLiderMasAlto>0){
			EvalResultado.decideResultadoLiderMasAlto(rJugadorDefensor, jDefensor, jAtacante);
			EvalResultado.decideResultado(rJugadorAtacante, jAtacante, jDefensor);
		}else{			
			EvalResultado.decideResultadoLiderMasAlto(rJugadorAtacante, jAtacante, jDefensor);
			EvalResultado.decideResultado(rJugadorDefensor, jDefensor, jAtacante);
			}
		Jugador jRes=null;
		if(rJugadorAtacante==5 || rJugadorAtacante==7){
			jRes=jDefensor;
		}else if(rJugadorDefensor==5 || rJugadorDefensor==7){
			jRes=jAtacante;
		}
		return jRes;
	}
	
	
	/// se comprueba si se desea utilizar el bonus segundo de su lider
	private void compruebaBonusSegundoLider(Jugador jAtacante, Jugador jDefensor) {
		Iterator<Jugador> ita = iteracionJugador(jAtacante, jDefensor);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			if(!jugador.isBooleanSeleccionaBonusPrimeroLider() && !jugador.getLider().getBonusSegundo().getValor().equals(0)){
				System.out.println("\nTurno del jugador: " + jugador.getNombre());
				System.out.println("¿Desea usar el segundo bonus de su Lider?: ");
				Boolean bSeleccionBonusLider=usarBonusLider();
				if(bSeleccionBonusLider){
					Batalla.usarBonusSegundoLider(jugador);	
				}
			}
		}
	}

					

	
/////////******************************************************///////////////////				
/////////****************** Metodos auxiliares ****************///////////////////
/////////******************************************************//////////////////					

	
	// permite al jugador elegir su mazo si la carta 4 no es la elegida
	
	private void decisionMazoEjercito(Jugador jugador, Integer numMax) {
		System.out.println("\nTurno del jugador: " + jugador.getNombre());
		if(!jugador.getTactica().getRequiere().equals(" ")){
			System.out.println("La tactica elegida requiere: " + jugador.getTactica().getRequiere());
		}
		
		if(jugador.getTactica().getValor().equals(4)){
			Ejercito mEjercito=(Ejercito) Jugador.seleccionaCarta(jugador.getReserva().getCartas());
			jugador.getReservaEnJuego().getCartas().add(mEjercito);		
		}else{
			System.out.println("Elija su mazo de Ejercito. De acuerdo al valor de su lider solo podra coger: " + numMax + " cartas de ejercito");
			System.out.println("¿Cuantas cartas de su mazo desea coger?");
			int seleccion = -1;
			int numero=0;
			while (seleccion == -1) {
				try {
					BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
					String linea = br.readLine();
					numero= Integer.parseInt(linea); 
					seleccion = 0;
					if (numero > jugador.getReserva().getCartas().size() || numero < 2)
						seleccion = -1;
				} catch (Exception e) {}
			} 
			ArrayList<Carta> mEjercito=Jugador.seleccionaMazo(jugador.getReserva().getCartas(), numero);
			jugador.getReservaEnJuego().getCartas().addAll(mEjercito);		
		}
		if(jugador.getTactica().getValor().equals(1)){
			jugador.getReserva().getCartas().add(mazotecnologia.sacaCartaPrimera());
		}
	}
	
//decide si los jugadores tienen solo 1 carta de ejercito en consecuencia pierde la partida el que tiene menor
	
	public void decideFinDePartida(Jugador j1, Jugador j2){
		Integer numReserva1 = j1.getReserva().size();
		Integer numReserva2 = j2.getReserva().size();
		Integer sumaBatallas = j1.getBatallasGanadas()+j2.getBatallasGanadas();
		
		Iterator<Jugador> ita = iteracionJugador(j1, j2);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			if(jugador.getBatallasGanadas()==6 || (sumaBatallas==10 && numReserva1>numReserva2) || (sumaBatallas==10 && numReserva1==numReserva2 && j1.getLider().getValor()>j2.getLider().getValor())){
				System.out.println("El ganador de toda la Partida es el jugador: " + jugador.getNombre() + "  ****FELICIDADEESS****");
				finDePartida=true;
			}
		}
	}
	
//Decide quien es el ganador del juego
	
	private Jugador decideGanador(Jugador jAtacante, Jugador jDefensor) {
		
		Integer puntosAtacante=Batalla.usarBonusSegundoLider(jAtacante);
		Integer puntosDefensor=Batalla.usarBonusSegundoLider(jDefensor);
		for(Carta c : jAtacante.getReservaEnJuego().getCartas()){
			puntosAtacante+=c.getValor();
		}
		for(Carta c : jDefensor.getReservaEnJuego().getCartas()){
			puntosDefensor+=c.getValor();
		}
		
		if(puntosAtacante>puntosDefensor){
			System.out.println("La batalla es para el jugador: " + jAtacante.getNombre() + " que tiene " + (puntosAtacante-puntosDefensor) + " puntos mas que el jugador " + jDefensor.getNombre());
			jAtacante.setBatallasGanadas(jAtacante.getBatallasGanadas()+1);
			return jAtacante;
		}else if(puntosAtacante<puntosDefensor){
			System.out.println("La batalla es para el jugador: " + jDefensor.getNombre()+ " que tiene " + (puntosDefensor-puntosAtacante) + " puntos mas que el jugador " + jAtacante.getNombre());
			jDefensor.setBatallasGanadas(jDefensor.getBatallasGanadas()+1);
			return jDefensor;
		}else if(comparaLideres(jAtacante,jDefensor)>0){
			System.out.println("La batalla es para el jugador: " + jAtacante.getNombre()+ " que tiene el lider de mayor rango");
			jAtacante.setBatallasGanadas(jAtacante.getBatallasGanadas()+1);
			return jAtacante;
		}else{
			System.out.println("La batalla es para el jugador: " + jDefensor.getNombre()+ " que tiene el lider de mayor rango");
			jDefensor.setBatallasGanadas(jDefensor.getBatallasGanadas()+1);
				return jDefensor;
		}
	
	}

				
	
	// comprueba que si se han utilzado cartas tacticas que requieran de alguna especial 
	//del ejercito estas se hayan utilizado, si no se han utilzado se cambia su carta tactica por la 2
	
	private void compruebaValorRequiereTactica(Jugador jAtacante,Jugador jDefensor) {
		Integer ordenesFallidas;
		Boolean noRequiere;
		Iterator<Jugador> ita = iteracionJugador(jAtacante, jDefensor);
		Jugador jugador;
		if(jAtacante.getReservaEnJuego().getCartas().size()> jAtacante.getLider().getValorMaximoAtaque()){
			System.out.println("El jugador "+ jDefensor.getNombre() +" debe eliminar el exceso de cartas de ejercito en juego del jugador "+jAtacante.getNombre());
			System.out.println(jDefensor.getNombre()+ " ¿Que cartas de ejercito desea retirar?:" );
			ArrayList<Carta> cEjercito= Jugador.seleccionaMazo(jAtacante.getReservaEnJuego().getCartas(),jAtacante.getReservaEnJuego().getCartas().size()-jAtacante.getLider().getValorMaximoAtaque());			
			jAtacante.getBajas().getCartas().addAll(cEjercito);
		}
		if(jDefensor.getReservaEnJuego().getCartas().size()>jDefensor.getLider().getValorMaximoDefensa()){
			System.out.println("El jugador "+ jAtacante.getNombre() +" debe eliminar el exceso de cartas de ejercito en juego del jugador "+jDefensor.getNombre());
			System.out.println(jAtacante.getNombre()+ " ¿Que cartas de ejercito desea retirar?:" );
			ArrayList<Carta> cEjercito1= Jugador.seleccionaMazo(jDefensor.getReservaEnJuego().getCartas(),jDefensor.getReservaEnJuego().getCartas().size()-jDefensor.getLider().getValorMaximoDefensa());			
			jDefensor.getBajas().getCartas().addAll(cEjercito1);	
		}
		while (ita.hasNext()) {
			jugador = ita.next();
			noRequiere=jugador.getTactica().getRequiere().equals(" ");
			if(!noRequiere){
				ordenesFallidas = ordenesFallidas(jugador);
				cambiaTacticaActualPorTactica2(jugador, ordenesFallidas);
			}
			else if(jugador.getTactica().getValor()>jugador.getLider().getValorMaximoTactica())
				cambiaTacticaActualPorTactica2(jugador, 1);	
		}	
	}
	
	// permite cambiar la carta tactica actual de un jugador por la 2
	private void cambiaTacticaActualPorTactica2(Jugador j1,Integer ordenesFallidas) {
		if(ordenesFallidas.equals(0)){
			System.out.println("El jugador: "+ j1.getNombre() + " ha usado una carta tactica que requiere una carta en concreto para su uso,\n\t    al no disponer de ella se le cambiara su tactica actual por la numero 2: Mantener y defenderse" );			
			j1.setTactica((Tactica)j1.getOrdenesDeBatalla().getCartas().get(1));
		}
		if(ordenesFallidas.equals(1)){
			System.out.println("El jugador: "+ j1.getNombre() + " ha usado una carta tactica que no puede ser utilizada por su lider,\n\t    se le cambiara su tactica actual por la numero 2: Mantener y defenderse" );			
			j1.setTactica((Tactica)j1.getOrdenesDeBatalla().getCartas().get(1));
		}
	}

	//se devuelven las cartas de los mazo de reserva jugados al mazo de reserva del jugador

	public void restauraCartasJugadas(Jugador j1, Jugador j2){

		Iterator<Jugador> ita = iteracionJugador(j1, j2);
		Jugador jugador;
		while (ita.hasNext()) {
			jugador = ita.next();
			jugador.getReserva().getCartas().addAll(jugador.getReservaEnJuego().getCartas());
			jugador.getReservaEnJuego().getCartas().clear();
			jugador.getReserva().ordena();
		}
	}

	

	//compara los valores de los lideres
	public Integer comparaLideres(Jugador j1,Jugador j2){
		return j1.getLider().getValor().compareTo(j2.getLider().getValor());
		
	}
				
				
			
/////////*******************************************************************************///////////////////				
/////////************** Metodos que permiten interactuar con el usuario ****************///////////////////
/////////*******************************************************************************//////////////////					
	
	// permite seleccionar el rol de un jugador
	private Boolean seleccionaRol(Collection<Rol> opcion) {
		int indice = 1;
		Iterator<Rol> ita = opcion.iterator();
		while (ita.hasNext()) {
			Rol r = ita.next();
			System.out.println(indice + ")" + r.toString());
			indice++;
		}
		
		int seleccion = -1;
		while (seleccion == -1) {
			try {
				System.out.print("Seleccione el rol de su jugador: ");
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
				String linea = br.readLine();
				seleccion = Integer.parseInt(linea);
				if (seleccion > 2 || seleccion <= 0)
					seleccion = -1;
			} catch (Exception e) {
			}
		}
		
		Boolean bRol=null;
		
		if (seleccion == 1) {
			bRol=true;	
		}	
		if (seleccion == 2) {
			bRol=false;		
		}		
		
		return bRol;
		
	}
	
// permite decidir al usuario virtual cambiar su lider actual

	private Boolean cambiaLider() {
		
		int indice = 1;
		for(int i=0;i<2;i++) {
			if(indice==1){
			System.out.println(indice + ")" + "Si");
			}else{
			System.out.println(indice + ")" + "No");
			}
			indice++;
		}
		
		int seleccion = -1;
		while (seleccion == -1) {
			try {
				System.out.print("Seleccione si quiere cambiar de lider: ");
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
				String linea = br.readLine();
				seleccion = Integer.parseInt(linea);
				if (seleccion > 2 || seleccion <= 0)
					seleccion = -1;
			} catch (Exception e) {
			}
		}
		
		Boolean res=null;
		
		if (seleccion == 1) {
			res=true;
		
		}	
		if (seleccion == 2) {
			res=false;
			
		}		
		
		return res;
		
	}
		
// el jugador decide si quiere usar el bonus de su carta lider
		
	private Boolean usarBonusLider() {
			
		int indice = 1;
		for(int i=0;i<2;i++) {
			if(indice==1){
			System.out.println(indice + ")" + "Si");
			}else{
			System.out.println(indice + ")" + "No");
			}
			indice++;
		}
						
			int seleccion = -1;
			while (seleccion == -1) {
				try {
					System.out.print("Seleccione si quiere usar el bonus de su lider: ");
					BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
					String linea = br.readLine();
					seleccion = Integer.parseInt(linea);
					if (seleccion > 2 || seleccion <= 0)
						seleccion = -1;
				} catch (Exception e) {
				}
			}
			
			Boolean res=null;
			
			if (seleccion == 1) {
				res=true;
			
			}	
			if (seleccion == 2) {
				res=false;
				
			}		
			
			return res;
			
	}
	
	// el jugador decide si quiere cambiar su carta tactica por la 4
	
	private Boolean cambiarCartaTactica() {
		
		int indice = 1;
		for(int i=0;i<2;i++) {
			if(indice==1){
			System.out.println(indice + ")" + "Si");
			}else{
			System.out.println(indice + ")" + "No");
			}
			indice++;
		}		
		int seleccion = -1;
		while (seleccion == -1) {
			try {
				System.out.print("Seleccione si quiere cambiar su carta tactica por la carta de retirada [4]: ");
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
				String linea = br.readLine();
				seleccion = Integer.parseInt(linea);
				if (seleccion > 2 || seleccion <= 0)
					seleccion = -1;
			} catch (Exception e) {
			}
		}
		
		Boolean res=null;
		
		if (seleccion == 1) {
			res=true;
		}	
		if (seleccion == 2) {
			res=false;
		}		
		return res;
		
	}
	
	private Iterator<Jugador> iteracionJugador(Jugador jAtacante, Jugador jDefensor){
		Collection<Jugador> cRol= new ArrayList<Jugador>();
		cRol.add(jAtacante);
		cRol.add(jDefensor);
		Iterator<Jugador> ita = cRol.iterator();
		return ita;
	}

}
	



